home *** CD-ROM | disk | FTP | other *** search
/ Chip 2006 June (Extra) / CHIP 2006-06.3.iso / program / opensource / Inkscape-0.43-2.win32.exe / share / extensions / ffproc.py < prev    next >
Encoding:
Python Source  |  2005-05-24  |  6.4 KB  |  195 lines
  1. #!/usr/bin/env python
  2. '''
  3.     Copyright (C) 2004 Aaron Cyril Spike
  4.  
  5.     This file is part of FretFind 2-D.
  6.  
  7.     FretFind 2-D is free software; you can redistribute it and/or modify
  8.     it under the terms of the GNU General Public License as published by
  9.     the Free Software Foundation; either version 2 of the License, or
  10.     (at your option) any later version.
  11.  
  12.     FretFind 2-D is distributed in the hope that it will be useful,
  13.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.     GNU General Public License for more details.
  16.  
  17.     You should have received a copy of the GNU General Public License
  18.     along with FretFind 2-D; if not, write to the Free Software
  19.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20. '''
  21. import sys
  22. from ffgeom import *
  23. threshold=0.0000000001
  24.  
  25. def FindFrets(strings, meta, scale, tuning, numfrets):
  26.     scale = scale['steps']
  27.  
  28.     #if the string ends don't fall on the nut and bridge
  29.     #don't look for partial frets.
  30.     numStrings = len(strings)
  31.     doPartials = True
  32.     parallelFrets = True
  33.     
  34.     nut = Segment(strings[0][0],strings[-1][0])
  35.     bridge = Segment(strings[0][1],strings[-1][1])
  36.     midline = Segment(
  37.         Point((nut[1]['x']+nut[0]['x'])/2.0,(nut[1]['y']+nut[0]['y'])/2.0),
  38.         Point((bridge[1]['x']+bridge[0]['x'])/2.0,(bridge[1]['y']+bridge[0]['y'])/2.0))
  39.     for s in strings:
  40.         if nut.distanceToPoint(s[0])>=threshold or bridge.distanceToPoint(s[1])>=threshold:
  41.             doPartials = False
  42.             break
  43.  
  44.     denom = ((bridge[1]['y']-bridge[0]['y'])*(nut[1]['x']-nut[0]['x']))-((bridge[1]['x']-bridge[0]['x'])*(nut[1]['y']-nut[0]['y']))
  45.     if denom != 0:
  46.         parallelFrets = False
  47.  
  48.     fretboard = []
  49.     tones = len(scale)-1
  50.     for i in range(len(strings)):
  51.         base = tuning[i]
  52.         frets = []
  53.         if doPartials:
  54.             frets.append(Segment(meta[i][0],meta[i+1][0]))
  55.         else:
  56.             frets.append(Segment(strings[i][0],strings[i][0]))
  57.         last = strings[i][0]
  58.  
  59.         for j in range(numfrets):
  60.             step=((base+j-1)%(tones))+1
  61.             ratio=1.0-((scale[step][1]*scale[step-1][0])/(scale[step][0]*scale[step-1][1]))
  62.             x = last['x']+(ratio*(strings[i][1]['x']-last['x']))
  63.             y = last['y']+(ratio*(strings[i][1]['y']-last['y']))
  64.             current = Point(x,y)    
  65.             temp = Segment(strings[i][0],current)
  66.             totalRatio = temp.length()/strings[i].length()
  67.             
  68.             if doPartials:
  69.                 #partials depending on outer strings (questionable)
  70.                 if parallelFrets:
  71.                     temp = nut.createParallel(current)
  72.                 else:
  73.                     temp = Segment(strings[0].pointAtLength(strings[0].length()*totalRatio),
  74.                         strings[-1].pointAtLength(strings[-1].length()*totalRatio))
  75.                 frets.append(Segment(intersectSegments(temp,meta[i]),intersectSegments(temp,meta[i+1])))
  76.             else:
  77.                 frets.append(Segment(current,current))
  78.             last = current
  79.         fretboard.append(frets)
  80.     return fretboard
  81.     
  82. def FindStringsSingleScale(numStrings,scaleLength,nutWidth,bridgeWidth,oNF,oBF,oNL,oBL):
  83.     strings = []
  84.     meta = []
  85.     nutHalf = nutWidth/2
  86.     bridgeHalf = bridgeWidth/2
  87.     nutCandidateCenter = (nutHalf) + oNL
  88.     bridgeCandidateCenter = (bridgeHalf) + oBL
  89.     if bridgeCandidateCenter >= nutCandidateCenter:
  90.         center = bridgeCandidateCenter
  91.     else:
  92.         center = nutCandidateCenter
  93.     nutStringSpacing = nutWidth/(numStrings-1)
  94.     bridgeStringSpacing = bridgeWidth/(numStrings-1)
  95.     
  96.     for i in range(numStrings):
  97.         strings.append(Segment(Point(center+nutHalf-(i*nutStringSpacing),0),
  98.             Point(center+bridgeHalf-(i*bridgeStringSpacing),scaleLength)))
  99.  
  100.     meta.append(Segment(Point(center+nutHalf+oNF,0),Point(center+bridgeHalf+oBF,scaleLength)))
  101.     for i in range(1,numStrings):
  102.         meta.append(Segment(
  103.             Point((strings[i-1][0]['x']+strings[i][0]['x'])/2.0,
  104.                 (strings[i-1][0]['y']+strings[i][0]['y'])/2.0),
  105.             Point((strings[i-1][1]['x']+strings[i][1]['x'])/2.0,
  106.                 (strings[i-1][1]['y']+strings[i][1]['y'])/2.0)))
  107.     meta.append(Segment(Point(center-(nutHalf+oNL),0),Point(center-(bridgeHalf+oBL),scaleLength)))
  108.  
  109.     return strings, meta
  110.  
  111. def FindStringsMultiScale(numStrings,scaleLengthF,scaleLengthL,nutWidth,bridgeWidth,perp,oNF,oBF,oNL,oBL):
  112.     strings = []
  113.     meta = []
  114.     nutHalf = nutWidth/2
  115.     bridgeHalf = bridgeWidth/2
  116.     nutCandidateCenter = (nutHalf)+oNL
  117.     bridgeCandidateCenter = (bridgeHalf)+oBL
  118.     if bridgeCandidateCenter >= nutCandidateCenter:
  119.         xcenter = bridgeCandidateCenter
  120.     else:
  121.         nutCandidateCenter
  122.  
  123.     fbnxf = xcenter+nutHalf+oNF
  124.     fbbxf = xcenter+bridgeHalf+oBF
  125.     fbnxl = xcenter-(nutHalf+oNL)
  126.     fbbxl = xcenter-(bridgeHalf+oBL)
  127.  
  128.     snxf = xcenter+nutHalf
  129.     sbxf = xcenter+bridgeHalf
  130.     snxl = xcenter-nutHalf
  131.     sbxl = xcenter-bridgeHalf
  132.  
  133.     fdeltax = sbxf-snxf
  134.     ldeltax = sbxl-snxl
  135.     fdeltay = math.sqrt((scaleLengthF*scaleLengthF)-(fdeltax*fdeltax))
  136.     ldeltay = math.sqrt((scaleLengthL*scaleLengthL)-(ldeltax*ldeltax))
  137.  
  138.     fperp = perp*fdeltay
  139.     lperp = perp*ldeltay
  140.  
  141.     #temporarily place first and last strings
  142.     first = Segment(Point(snxf,0),Point(sbxf,fdeltay))
  143.     last = Segment(Point(snxl,0),Point(sbxl,ldeltay))
  144.     
  145.     if fdeltay<=ldeltay:
  146.         first.translate(0,(lperp-fperp))
  147.     else:
  148.         last.translate(0,(fperp-lperp))
  149.  
  150.     nut = Segment(first[0].copy(),last[0].copy())
  151.     bridge = Segment(first[1].copy(),last[1].copy())
  152.     #overhang measurements are now converted from delta x to along line lengths
  153.     oNF = (oNF*nut.length())/nutWidth
  154.     oNL = (oNL*nut.length())/nutWidth
  155.     oBF = (oBF*bridge.length())/bridgeWidth
  156.     oBL = (oBL*bridge.length())/bridgeWidth
  157.     #place fretboard edges
  158.     fbf = Segment(nut.pointAtLength(-oNF),bridge.pointAtLength(-oBF))
  159.     fbl = Segment(nut.pointAtLength(nut.length()+oNL),bridge.pointAtLength(bridge.length()+oBL))
  160.     #normalize values into the first quadrant via translate
  161.     if fbf[0]['y']<0 or fbl[0]['y']<0:
  162.         if fbf[0]['y']<=fbl[0]['y']:
  163.             move = -fbf[0]['y']
  164.         else:
  165.             move = -fbl[0]['y']
  166.         
  167.         first.translate(0,move)
  168.         last.translate(0,move)
  169.         nut.translate(0,move)
  170.         bridge.translate(0,move)
  171.         fbf.translate(0,move)
  172.         fbl.translate(0,move)
  173.  
  174.     #output values
  175.     nutStringSpacing = nut.length()/(numStrings-1)
  176.     bridgeStringSpacing = bridge.length()/(numStrings-1)
  177.     strings.append(first)
  178.     for i in range(1,numStrings-1):
  179.         n = nut.pointAtLength(i*nutStringSpacing)
  180.         b = bridge.pointAtLength(i*bridgeStringSpacing)
  181.         strings.append(Segment(Point(n['x'],n['y']),Point(b['x'],b['y'])))
  182.     strings.append(last)
  183.  
  184.     meta.append(fbf)
  185.     for i in range(1,numStrings):
  186.         meta.append(Segment(
  187.             Point((strings[i-1][0]['x']+strings[i][0]['x'])/2.0,
  188.                 (strings[i-1][0]['y']+strings[i][0]['y'])/2.0),
  189.             Point((strings[i-1][1]['x']+strings[i][1]['x'])/2.0,
  190.                 (strings[i-1][1]['y']+strings[i][1]['y'])/2.0)))
  191.     
  192.     meta.append(fbl)
  193.     
  194.     return strings, meta
  195.